package qc.module.ehs.service;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import qc.common.core.exception.QCPromptException;
import qc.common.core.unify.QCUnifyReturnValue;
import qc.module.ehs.dto.org.EhsOrgDto;
import qc.module.ehs.dto.unit.EhsUnitDto;
import qc.module.ehs.entity.EhsOrg;
import qc.module.ehs.mapper.EhsOrgMapper;
import qc.module.ehs.repository.EhsOrgRepository;

import java.util.List;
import java.util.Objects;

/**
 * 组织信息接口Service
 *
 * @author QuCheng Tech
 * @create 2024/5/22
 */
@Service
public class EhsOrgService {
    
    private EhsOrgRepository repository;

    @Autowired
    public void setRepository(EhsOrgRepository repository) {
        this.repository = repository;
    }
    
    @Autowired
    private EhsUnitInfoService unitBasicService;
    /**
     * 获取所有
     *
     * @return List<EhsOrgDto> 组织信息DTO集合
     * @author QuCheng Tech
     * @since 2024/5/22
     */
    public List<EhsOrgDto> getAll(){
        LambdaQueryWrapper<EhsOrg> wrapper = new LambdaQueryWrapper<>();
        wrapper.orderByAsc(EhsOrg::getOrgcode);
        List<EhsOrg> ens = repository.selectList(wrapper);
        
        if (CollectionUtils.isNotEmpty(ens)){
            return EhsOrgMapper.MAPPER.toDtoList(ens);
        }
        return null;
    }

    /**
     * 获取指定
     *
     * @param id 组织代码
     * @return EhsOrgDto 组织信息DTO
     * @author QuCheng Tech
     * @since 2024/5/22
     */
    public EhsOrgDto get(String id) throws QCPromptException {
        EhsOrg en = getEntity(id);
        if (Objects.nonNull(en)) {
            return EhsOrgMapper.MAPPER.toDto(en);
        }
        return null;
    }

    /***
     * 获取指定的组织信息Entity
     *
     * @param orgcode 组织代码
     * @return qc.module.ehs.entity.EhsOrg
     * @author QuCheng Tech
     * @since 2025/2/28
     */
    public EhsOrg getEntity(String orgcode) throws QCPromptException {
        if (StringUtils.isBlank(orgcode))
            throw new QCPromptException("获取组织信息时组织代码不能为空");

        return repository.selectById(orgcode);
    }

    /**
     * 新增
     *
     * @param dto 组织信息
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/5/22
     */
    public String add(EhsOrgDto dto) {
        //1.新增对象判断
        if (dto == null) return QCUnifyReturnValue.Warn("组织信息不能为空");
        if (StringUtils.isBlank(dto.getOrgcode())) return QCUnifyReturnValue.Warn("组织代码不能为空");
        if (StringUtils.isBlank(dto.getOrgname())) return QCUnifyReturnValue.Warn("组织名称不能为空");
        if (dto.getDeptid() < 0x1) return QCUnifyReturnValue.Warn("部门ID无效");
        if (dto.getOrgtype() < 0x1) return QCUnifyReturnValue.Warn("组织类型无效");

        //2.判断新增对象是否已经存在，存在则提示
        if (isExist(dto.getOrgcode())) return QCUnifyReturnValue.Warn("组织代码已经存在");

        //3.dto -> entity
        EhsOrg en = EhsOrgMapper.MAPPER.dtoToEntity(dto);

        //4.保存数据
        if (repository.insert(en) < 0x1) {
            return QCUnifyReturnValue.Warn("保存失败");
        }
        return QCUnifyReturnValue.Success();
    }

    /**
     * 修改
     *
     * @param dto 组织信息
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/5/22
     */
    public String update(EhsOrgDto dto) {
        //1.修改对象判断
        if (dto == null) return QCUnifyReturnValue.Warn("组织信息不能为空");
        if (StringUtils.isBlank(dto.getOrgcode())) return QCUnifyReturnValue.Warn("组织代码不能为空");
        if (StringUtils.isBlank(dto.getOrgname())) return QCUnifyReturnValue.Warn("组织名称不能为空");
        if (dto.getDeptid() < 0x1) return QCUnifyReturnValue.Warn("部门ID无效");
        if (dto.getOrgtype() < 0x1) return QCUnifyReturnValue.Warn("组织类型无效");

        //2.判断修改对象是否已经存在，不存在则提示
        if (!isExist(dto.getOrgcode())) return QCUnifyReturnValue.Warn("组织代码不存在");

        //3.dto -> entity
        EhsOrg en = EhsOrgMapper.MAPPER.dtoToEntity(dto);

        //4.修改数据
        repository.updateById(en);
        return QCUnifyReturnValue.Success();
    }

    /**
     * 删除
     *
     * @param id 组织代码
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/5/22
     */
    public String delete(String id){
        if (StringUtils.isBlank(id)) return QCUnifyReturnValue.Warn("组织代码不能为空");
        
        //判断组织下是否有单元信息，有则不允许删除
        List<EhsUnitDto> unitDtos = unitBasicService.getUnitByOrgCode(id);
        if (CollectionUtils.isNotEmpty(unitDtos)) return QCUnifyReturnValue.Warn("该组织下有单元信息，请先删除单元信息");
        
        repository.deleteById(id);
        return QCUnifyReturnValue.Success();
    }

    /**
     * 根据部门ID获取对应的组织信息，如果没有对应或对应多个抛出提示信息
     *
     * @param deptIds 部门ID集合
     * @return EhsOrgDto
     * @throws QCPromptException
     * @author QuCheng Tech
     * @since 2024/6/11
     */
    public EhsOrgDto getOrgByDeptIds(List<Integer> deptIds) throws QCPromptException {
        if (deptIds == null || deptIds.size() < 0x1)
            throw new QCPromptException("根据部门ID获取对应的组织信息时部门ID集合不能为空");

        //根据根部门ID集合查询组织
        LambdaQueryWrapper<EhsOrg> wrapper = new LambdaQueryWrapper<>();
        if (deptIds.size() > 0x1)
            wrapper.in(EhsOrg::getDeptid, deptIds);
        else
            wrapper.eq(EhsOrg::getDeptid, deptIds.get(0x0).intValue());

        List<EhsOrg> ehsOrgs = repository.selectList(wrapper);
        if (ehsOrgs == null || ehsOrgs.size() < 0x1)
            throw new QCPromptException("根据部门ID获取对应的组织信息为空");

        if (ehsOrgs.size() > 0x1)
            throw new QCPromptException("根据部门ID获取对应的组织信息存在多个，请检查配置");

        //返回第1个
        return EhsOrgMapper.MAPPER.toDto(ehsOrgs.get(0x0));
    }

    /**
     * 判断组织代码是否存在
     * 
     * @param id 组织代码
     * @return 存在返回true，否则返回false
     * @author QuCheng Tech
     * @since 2024/5/22
     */
    public boolean isExist(String id){
        EhsOrg en = repository.selectById(id);
        if (Objects.nonNull(en)){
            return true;
        }
        return false;
    }
}
